home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / istream.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-09  |  40.3 KB  |  1,966 lines
  1. #ifndef __ISTREAM_CC
  2. #define __ISTREAM_CC
  3. #pragma option push -b -a4 -Vx- -Ve- -w-inl -w-aus -w-sig
  4.  
  5. /***************************************************************************
  6.  *
  7.  * istream.cc - istream definitions
  8.  *
  9.  * (c) Copyright 1994, 1995 Rogue Wave Software, Inc.
  10.  * ALL RIGHTS RESERVED *
  11.  * The software and information contained herein are proprietary to, and
  12.  * comprise valuable trade secrets of, Rogue Wave Software, Inc., which
  13.  * intends to preserve as trade secrets such software and information.
  14.  * This software is furnished pursuant to a written license agreement and
  15.  * may be used, copied, transmitted, and stored only in accordance with
  16.  * the terms of such license and with the inclusion of the above copyright
  17.  * notice.  This software and information or any other copies thereof may
  18.  * not be provided or otherwise made available to any other person.
  19.  *
  20.  * Notwithstanding any other lease or license that may pertain to, or
  21.  * accompany the delivery of, this computer software and information, the
  22.  * rights of the Government regarding its use, reproduction and disclosure
  23.  * are as set forth in Section 52.227-19 of the FARS Computer
  24.  * Software-Restricted Rights clause.
  25.  * 
  26.  * Use, duplication, or disclosure by the Government is subject to
  27.  * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
  28.  * Technical Data and Computer Software clause at DFARS 252.227-7013.
  29.  * Contractor/Manufacturer is Rogue Wave Software, Inc.,
  30.  * P.O. Box 2328, Corvallis, Oregon 97339.
  31.  *
  32.  * This computer software and information is distributed with "restricted
  33.  * rights."  Use, duplication or disclosure is subject to restrictions as
  34.  * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial
  35.  * Computer Software-Restricted Rights (April 1985)."  If the Clause at
  36.  * 18-52.227-74 "Rights in Data General" is specified in the contract,
  37.  * then the "Alternate III" clause applies.
  38.  *
  39.  **************************************************************************/
  40.  
  41. #ifndef _RWSTD_NO_NEW_HEADER
  42. #include <cctype>
  43. #else
  44. #include <ctype.h>
  45. #endif
  46.  
  47. #include <ios>
  48.  
  49. #ifndef _RWSTD_NO_NAMESPACE
  50. namespace std {
  51. #endif
  52.  
  53. /*
  54.  * Standard basic_istream manipulators
  55.  *
  56.  * skips the next available white spaces
  57.  */
  58.  
  59. template<class charT, class traits>
  60. basic_istream<charT, traits>&
  61. _RWSTDExport ws(basic_istream<charT, traits>& is)
  62. {
  63.    _TYPENAME traits::int_type        c;
  64.  
  65.    #ifdef _RWSTD_MULTI_THREAD
  66.     #ifndef _RWSTD_NO_EXCEPTIONS
  67.      try {
  68.     #endif
  69.      if ( is.rdbuf() )
  70.      {
  71.        _RWSTDGuard* tmp = new _RWSTDGuard(is.rdbuf()->buffer_mutex_);
  72.        if ( tmp )
  73.               is.istream_sentry_guard = tmp;
  74.              else
  75.               is.istream_sentry_guard = 0;
  76.      }
  77.    #endif
  78.  
  79.  
  80.    #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  81.      const ctype<charT>& ct = use_facet< ctype<charT> >(is.getloc());
  82.    #else
  83.      const ctype<charT>& ct = use_facet(is.getloc(),(ctype<charT>*)0);
  84.    #endif
  85.          
  86.    while((c = is.rdbuf()->sgetc()),
  87.          ( !traits::eq_int_type(c,traits::eof()) && ct.is(ct.space,c) )) 
  88.     is.rdbuf()->snextc();
  89.  
  90.    if( traits::eq_int_type(c,traits::eof()) )
  91.      is.setstate(ios_base::eofbit);
  92.        
  93.   #ifdef _RWSTD_MULTI_THREAD
  94.    if ( is.istream_sentry_guard )
  95.     {
  96.       delete is.istream_sentry_guard;
  97.       is.istream_sentry_guard = 0;
  98.     }
  99.   #endif
  100.  
  101. #ifdef _RWSTD_MULTI_THREAD
  102.  #ifndef _RWSTD_NO_EXCEPTIONS
  103.   }
  104.  
  105.   catch(...)
  106.   {
  107.     if ( is.istream_sentry_guard )
  108.     {
  109.       delete is.istream_sentry_guard;
  110.       is.istream_sentry_guard = 0;
  111.       throw;
  112.     }
  113.   }
  114.  #endif
  115. #endif
  116.  
  117.  
  118.  
  119.   return is;
  120. }
  121.  
  122.  
  123.  
  124. /*
  125.  * basic_istream(basic_streambuf *)
  126.  */
  127.  
  128. template<class charT, class traits>
  129. basic_istream<charT, traits>::
  130. basic_istream(basic_streambuf<charT, traits> *sb)
  131. : chcount_(0)
  132. {
  133.   if ( sb )
  134.    {
  135.      if ( sb->which_open_mode() & ios_base::in )
  136.        init(sb);
  137.      else
  138.        init(0);
  139.    } 
  140.   else
  141.    init(0); 
  142. }
  143.  
  144. /*
  145.  * basic_istream( )
  146.  */
  147.  
  148. template<class charT, class traits>
  149. basic_istream<charT, traits>::
  150. basic_istream( )
  151. : chcount_(0)
  152. { 
  153. }
  154.  
  155.  
  156. /*
  157.  * ~basic_istream();
  158.  */
  159.  
  160. template<class charT, class traits>
  161. basic_istream<charT, traits>::~basic_istream()
  162. {
  163.  
  164. }
  165.  
  166. /*
  167.  * istream_type& operator>>(istream_type& (*pf)(istream_type&))
  168.  *
  169.  * for functions relating to istreams
  170.  */
  171.  
  172. template<class charT, class traits>
  173. basic_istream<charT, traits>&
  174. basic_istream<charT, traits>::
  175. operator>>(basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&))
  176. {
  177.   (*pf)(*this);
  178.   return *this;
  179. }
  180.  
  181.  
  182. /*
  183.  * istream_type& operator>>(ios_base& (*pf)(ios_base&))
  184.  *
  185.  * for manipulators relating to the ios_base class
  186.  */
  187.  
  188. template<class charT, class traits>
  189. basic_istream<charT, traits>&
  190. basic_istream<charT, traits>::
  191. operator>>(ios_base& (*pf)(ios_base&))
  192. {
  193.   (*pf)(*this);
  194.  
  195.   return *this;
  196. }
  197.  
  198. /*
  199.  * istream_type& operator>>(ios_type& (*pf)(ios_type&))
  200.  *
  201.  * used to set one of the ios states (ios manipulator)
  202.  */
  203.  
  204. template<class charT, class traits>
  205. basic_istream<charT, traits>&
  206. basic_istream<charT, traits>::
  207. operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&))
  208. {
  209.   (*pf)(*this);
  210.  
  211.   return *this;
  212. }
  213.  
  214. /*
  215.  * basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>, charT *)
  216.  *
  217.  * read in a charT *. 
  218.  */
  219.  
  220. template<class charT, class traits>
  221. basic_istream<charT, traits>&
  222. _RWSTDExport operator>>(basic_istream<charT, traits>& is, charT *p)
  223. {
  224.   ios_base::iostate err = 0;
  225.  
  226.   #ifndef _RWSTD_NO_EXCEPTIONS
  227.   try {
  228.   #endif  
  229.  
  230.  if ( p!=0 )
  231.  {
  232.  
  233.   _TYPENAME basic_istream<charT, traits>::sentry ipfx(is);
  234.  
  235.   if(ipfx) { 
  236.      charT                      *op = p;
  237.      _TYPENAME traits::int_type  c = 0;
  238.      int                        len; 
  239.  
  240.   if ( is.width() == 0 ) len=0; 
  241.   else len=is.width(); 
  242.  
  243.          #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  244.           const ctype<charT>& ct = use_facet< ctype<charT> >(is.getloc());
  245.          #else
  246.           const ctype<charT>& ct = use_facet(is.getloc(), (ctype<charT>*)0);
  247.          #endif
  248.  
  249.      while(--len &&
  250.                (c = is.rdbuf()->sgetc(),!( traits::eq_int_type(c,traits::eof()) ||
  251.                 ct.is(ct.space,c))))
  252.         {
  253.             *p++ = c;
  254.         is.rdbuf()->sbumpc();
  255.      }
  256.     
  257.      if( traits::eq_int_type(c,traits::eof()) )
  258.         err = ((p == op) ? 
  259.                   (ios_base::eofbit | ios_base::failbit) : ios_base::eofbit);
  260.      *p = charT ('\0');  
  261.      is.width(0); 
  262.   }
  263.  
  264. }
  265. else
  266.   err = ios_base::failbit;
  267.  
  268.   #ifndef _RWSTD_NO_EXCEPTIONS
  269.   }
  270.   #endif
  271.  
  272.   #ifndef _RWSTD_NO_EXCEPTIONS
  273.   catch(...)
  274.   {
  275.     bool flag = false;
  276.     try {
  277.            is.setstate(ios_base::badbit);
  278.         }
  279.     catch( ios_base::failure ) { flag= true; }
  280.     if ( flag ) throw;
  281.   }
  282.   #endif
  283.  
  284.   if ( err ) is.setstate(err);
  285.  
  286.   return is;
  287. }
  288.  
  289. /*
  290.  * basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&, charT& )
  291.  *
  292.  * read in a character
  293.  */
  294.  
  295. template<class charT, class traits>
  296. basic_istream<charT, traits>&
  297. _RWSTDExport operator>>(basic_istream<charT,traits>& is, charT& c)
  298. {
  299.  ios_base::iostate err = 0;
  300.  
  301.   #ifndef _RWSTD_NO_EXCEPTIONS
  302.   try {
  303.   #endif  
  304.  
  305.   _TYPENAME basic_istream<charT, traits>::sentry ipfx(is);
  306.  
  307.   if(ipfx) { 
  308.              _TYPENAME traits::int_type tmp = is.rdbuf()->sbumpc();
  309.              if ( traits::eq_int_type(traits::eof(),tmp) ) 
  310.                err = ios_base::failbit | ios_base::eofbit;
  311.              else
  312.                c = traits::to_char_type(tmp);
  313.   }
  314.  
  315.   #ifndef _RWSTD_NO_EXCEPTIONS
  316.   }
  317.   #endif
  318.  
  319.   
  320.   #ifndef _RWSTD_NO_EXCEPTIONS
  321.   catch(...)
  322.   {
  323.     bool flag = false;
  324.     try {
  325.            is.setstate(ios_base::badbit);
  326.         }
  327.     catch( ios_base::failure ) { flag= true; }
  328.     if ( flag ) throw;
  329.   }
  330.   #endif
  331.  
  332.   if ( err ) is.setstate(err);
  333.  
  334.   return is;
  335. }
  336.  
  337.  
  338. #ifndef _RWSTD_NO_SIGNED_CHAR_IN_STREAMS
  339. /*
  340.  * istream& operator>>(basic_istream<char,traits>&,unsigned char& )
  341.  *
  342.  */
  343.  
  344. template <class traits>
  345. basic_istream<char, traits>&
  346. _RWSTDExport operator>>(basic_istream<char, traits>& is, unsigned char& uc)
  347. {
  348.   is >> (char &)uc;
  349.  
  350.   return is;
  351. }
  352.  
  353. /*
  354.  * istream& operator>>(basic_istream<char, traits>&, signed char& )
  355.  *
  356.  */
  357.  
  358. template <class traits>
  359. basic_istream<char, traits>&
  360. _RWSTDExport operator>>(basic_istream<char, traits>& is, signed char& sc)
  361. {
  362.   is >> (char &)sc;
  363.  
  364.   return is;
  365. }
  366.  
  367.  
  368. /*
  369.  * istream& operator>>(basic_istream<char, traits>&, unsigned char* )
  370.  *
  371.  */
  372.  
  373. template <class traits>
  374. basic_istream<char, traits>&
  375. _RWSTDExport operator>>(basic_istream<char, traits>& is,unsigned char* uc)
  376. {
  377.   is >> (char *)uc;
  378.  
  379.   return is;
  380. }
  381.  
  382. /*
  383.  * istream& operator>>(basic_istream<char, traits>&,signed char* )
  384.  *
  385.  */
  386.  
  387. template <class traits>
  388. basic_istream<char, traits>&
  389. _RWSTDExport operator>>(basic_istream<char, traits>& is, signed char* sc)
  390. {
  391.    is >> (char *)sc;
  392.  
  393.    return is;
  394. }
  395.  
  396. #endif
  397.  
  398. #ifndef _RWSTD_NO_BOOL
  399. /*
  400.  * istream_type& operator>>(bool&)
  401.  */
  402.  
  403. template<class charT, class traits>
  404. basic_istream<charT, traits>&
  405. basic_istream<charT, traits>::operator>>(bool& n)
  406. {
  407.  ios_base::iostate err = 0;
  408.  
  409.  #ifndef _RWSTD_NO_EXCEPTIONS
  410.  try {
  411.  #endif
  412.  
  413.   _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  414.  
  415.   if(ipfx) 
  416.  {
  417.    #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  418.     use_facet<num_get<charT,istreambuf_iterator<charT,traits> > >(this->getloc())
  419.    #else
  420.     use_facet(this->getloc(),(num_get<charT,istreambuf_iterator<charT,traits> >*)0)
  421.    #endif
  422.      .get(istreambuf_iterator<charT,traits>(*this),istreambuf_iterator<charT,traits>(),*this,err,n);
  423.   }
  424.  
  425.   #ifndef _RWSTD_NO_EXCEPTIONS
  426.   }
  427.   #endif
  428.  
  429.   #ifndef _RWSTD_NO_EXCEPTIONS
  430.   catch(...)
  431.   {
  432.     bool flag = false;
  433.     try {
  434.            this->setstate(ios_base::badbit);
  435.         }
  436.     catch( ios_base::failure ) { flag= true; }
  437.     if ( flag ) throw;
  438.   }
  439.   #endif
  440.  
  441.   if ( err ) this->setstate(err);
  442.   
  443.   return *this;
  444. }
  445.  
  446. #endif /* _RWSTD_NO_BOOL */
  447.  
  448. /*
  449.  * istream_type& operator>>(short&)
  450.  */
  451.  
  452. template<class charT, class traits>
  453. basic_istream<charT, traits>&
  454. basic_istream<charT, traits>::operator>>(short& n)
  455. {
  456.  ios_base::iostate err = 0;
  457.  
  458.  #ifndef _RWSTD_NO_EXCEPTIONS
  459.  try {
  460.  #endif 
  461.  
  462.  _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  463.  
  464.  if(ipfx) 
  465.  {
  466.   long l;
  467.   #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  468.    use_facet<num_get<charT,istreambuf_iterator<charT,traits> > >(this->getloc())
  469.   #else
  470.    use_facet(this->getloc(),(num_get<charT,istreambuf_iterator<charT,traits> >*)0)
  471.   #endif
  472.   .get(istreambuf_iterator<charT,traits>(*this),istreambuf_iterator<charT,traits>(),*this,err,l);
  473.   n=(short)l;
  474.   if ( (n!=l) && ((unsigned short)n != l) )
  475.    err |= ios_base::failbit;
  476.  }
  477.  
  478. #ifndef _RWSTD_NO_EXCEPTIONS
  479.   }
  480.   #endif
  481.  
  482.   #ifndef _RWSTD_NO_EXCEPTIONS
  483.   catch(...)
  484.   {
  485.     bool flag = false;
  486.     try {
  487.            this->setstate(ios_base::badbit);
  488.         }
  489.     catch( ios_base::failure ) { flag= true; }
  490.     if ( flag ) throw;
  491.   }
  492.   #endif
  493.  
  494.   if ( err ) this->setstate(err);
  495.  
  496.   return *this;
  497.  
  498.  }
  499.  
  500. /*
  501.  * istream_type& operator>>(unsigned short&)
  502.  */
  503. template<class charT, class traits>
  504. basic_istream<charT, traits>&
  505. basic_istream<charT, traits>::operator>>(unsigned short& n)
  506. {
  507.   ios_base::iostate err = 0;
  508.  
  509.   #ifndef _RWSTD_NO_EXCEPTIONS
  510.   try {
  511.   #endif
  512.  
  513.   _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  514.  
  515.  
  516.   if(ipfx) {
  517.             #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  518.              use_facet<num_get<charT,istreambuf_iterator<charT,traits> > >(this->getloc())
  519.             #else
  520.              use_facet(this->getloc(),(num_get<charT,istreambuf_iterator<charT,traits> >*)0)
  521.             #endif
  522.              .get(istreambuf_iterator<charT,traits>(*this),istreambuf_iterator<charT,traits>(),*this,err,n);
  523.           }
  524.  
  525.   #ifndef _RWSTD_NO_EXCEPTIONS
  526.   }
  527.   #endif
  528.  
  529.   #ifndef _RWSTD_NO_EXCEPTIONS
  530.   catch(...)
  531.   {
  532.     bool flag = false;
  533.     try {
  534.            this->setstate(ios_base::badbit);
  535.         }
  536.     catch( ios_base::failure ) { flag= true; }
  537.     if ( flag ) throw;
  538.   }
  539.   #endif
  540.  
  541.   if ( err ) this->setstate(err);
  542.  
  543.   return *this;
  544.  
  545. }
  546.  
  547.  
  548. /*
  549.  * istream_type& operator>>(int&)
  550.  */
  551.  
  552. template<class charT, class traits>
  553. basic_istream<charT, traits>&
  554. basic_istream<charT, traits>::operator>>(int& n)
  555. {
  556.  ios_base::iostate err = 0;
  557.  
  558.  #ifndef _RWSTD_NO_EXCEPTIONS
  559.  try {
  560.  #endif
  561.  
  562.  _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  563.  
  564.  if(ipfx) {
  565.  
  566.           long l;
  567.           #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  568.            use_facet<num_get<charT,istreambuf_iterator<charT,traits> > >(this->getloc())
  569.           #else
  570.            use_facet(this->getloc(),(num_get<charT,istreambuf_iterator<charT,traits> >*)0)
  571.           #endif
  572.            .get(istreambuf_iterator<charT,traits>(*this),istreambuf_iterator<charT,traits>(),*this,err,l);
  573.            n=(int)l;
  574.            if ( (n!=l) && ((unsigned int)n!=(unsigned long)l) )
  575.            err |= ios_base::failbit;
  576.          }
  577.  
  578.   #ifndef _RWSTD_NO_EXCEPTIONS
  579.   }
  580.   #endif
  581.  
  582.   #ifndef _RWSTD_NO_EXCEPTIONS
  583.   catch(...)
  584.   {
  585.     bool flag = false;
  586.     try {
  587.            this->setstate(ios_base::badbit);
  588.         }
  589.     catch( ios_base::failure ) { flag= true; }
  590.     if ( flag ) throw;
  591.   }
  592.   #endif
  593.  
  594.   if ( err ) this->setstate(err);
  595.  
  596.   return *this;
  597. }
  598.  
  599. /*
  600.  * istream_type& operator>>(unsigned int&)
  601.  */
  602.  
  603. template<class charT, class traits>
  604. basic_istream<charT, traits>&
  605. basic_istream<charT, traits>::operator>>(unsigned int& n)
  606. {
  607.  ios_base::iostate err = 0;
  608.  
  609.  #ifndef _RWSTD_NO_EXCEPTIONS
  610.  try {
  611.  #endif
  612.  
  613.  _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  614.  
  615.  if(ipfx) {
  616.             #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  617.              use_facet<num_get<charT,istreambuf_iterator<charT,traits> > >(this->getloc())
  618.             #else
  619.              use_facet(this->getloc(),(num_get<charT,istreambuf_iterator<charT,traits> >*)0)
  620.             #endif
  621.             .get(istreambuf_iterator<charT,traits>(*this),istreambuf_iterator<charT,traits>(),*this,err,n);
  622.           }
  623.  
  624.   #ifndef _RWSTD_NO_EXCEPTIONS
  625.   }
  626.   #endif
  627.  
  628.   #ifndef _RWSTD_NO_EXCEPTIONS
  629.   catch(...)
  630.   {
  631.     bool flag = false;
  632.     try {
  633.            this->setstate(ios_base::badbit);
  634.         }
  635.     catch( ios_base::failure ) { flag= true; }
  636.     if ( flag ) throw;
  637.   }
  638.   #endif
  639.  
  640.   if ( err ) this->setstate(err); 
  641.  
  642.   return *this;
  643.  
  644. }
  645.  
  646. /*
  647.  * istream_type& operator>>(long&)
  648.  */
  649.  
  650. template<class charT, class traits>
  651. basic_istream<charT, traits>&
  652. basic_istream<charT, traits>::operator>>(long& n)
  653. {
  654.  ios_base::iostate err = 0;
  655.  
  656.  #ifndef _RWSTD_NO_EXCEPTIONS
  657.  try {
  658.  #endif
  659.  
  660.  _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  661.  
  662.  if(ipfx) {
  663.  
  664.            #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  665.             use_facet<num_get<charT,istreambuf_iterator<charT,traits> > >(this->getloc())
  666.            #else
  667.             use_facet(this->getloc(),(num_get<charT,istreambuf_iterator<charT,traits> >*)0)
  668.            #endif
  669.            .get(istreambuf_iterator<charT,traits>(*this),istreambuf_iterator<charT,traits>(),*this,err,n);
  670.           }
  671.  
  672.   #ifndef _RWSTD_NO_EXCEPTIONS
  673.   }
  674.   #endif
  675.  
  676.   #ifndef _RWSTD_NO_EXCEPTIONS
  677.   catch(...)
  678.   {
  679.     bool flag = false;
  680.     try {
  681.            this->setstate(ios_base::badbit);
  682.         }
  683.     catch( ios_base::failure ) { flag= true; }
  684.     if ( flag ) throw;
  685.   }
  686.   #endif
  687.  
  688.   if ( err ) this->setstate(err);
  689.  
  690.   return *this;
  691.  
  692.   
  693. }
  694.  
  695. /*
  696.  * istream_type& operator>>(unsigned long&)
  697.  */
  698.  
  699. template<class charT, class traits>
  700. basic_istream<charT, traits>&
  701. basic_istream<charT, traits>::operator>>(unsigned long& n)
  702. {
  703.  ios_base::iostate err = 0;
  704.  
  705.  #ifndef _RWSTD_NO_EXCEPTIONS
  706.  try {
  707.  #endif
  708.  
  709. _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  710.  
  711.  if(ipfx) {
  712.             #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  713.              use_facet<num_get<charT,istreambuf_iterator<charT,traits> > >(this->getloc())
  714.             #else
  715.              use_facet(this->getloc(),(num_get<charT,istreambuf_iterator<charT,traits> >*)0)
  716.             #endif
  717.             .get(istreambuf_iterator<charT,traits>(*this),istreambuf_iterator<charT,traits>(),*this,err,n);
  718.            }
  719.  
  720.   #ifndef _RWSTD_NO_EXCEPTIONS
  721.   }
  722.   #endif
  723.  
  724.   #ifndef _RWSTD_NO_EXCEPTIONS
  725.   catch(...)
  726.   {
  727.     bool flag = false;
  728.     try {
  729.            this->setstate(ios_base::badbit);
  730.         }
  731.     catch( ios_base::failure ) { flag= true; }
  732.     if ( flag ) throw;
  733.   }
  734.   #endif
  735.  
  736.   if ( err ) this->setstate(err);
  737.  
  738.   return *this;
  739. }
  740.  
  741. /*
  742.  * istream_type& operator>>(float&)
  743.  */
  744.  
  745. template<class charT, class traits>
  746. basic_istream<charT, traits>&
  747. basic_istream<charT, traits>::operator>>(float& f)
  748. {
  749.  ios_base::iostate err = 0;
  750.  
  751.  #ifndef _RWSTD_NO_EXCEPTIONS
  752.  try {
  753.  #endif
  754.  
  755.  _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  756.  
  757.  if(ipfx) { 
  758.             #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  759.              use_facet<num_get<charT,istreambuf_iterator<charT,traits> > >(this->getloc())
  760.             #else
  761.              use_facet(this->getloc(),(num_get<charT,istreambuf_iterator<charT,traits> >*)0)
  762.             #endif
  763.             .get(istreambuf_iterator<charT,traits>(*this),istreambuf_iterator<charT,traits>(),*this,err,f);
  764.           }
  765.  
  766.   #ifndef _RWSTD_NO_EXCEPTIONS
  767.   }
  768.   #endif
  769.  
  770.   #ifndef _RWSTD_NO_EXCEPTIONS
  771.   catch(...)
  772.   {
  773.     bool flag = false;
  774.     try {
  775.            this->setstate(ios_base::badbit);
  776.         }
  777.     catch( ios_base::failure ) { flag= true; }
  778.     if ( flag ) throw;
  779.   }
  780.   #endif
  781.  
  782.   if ( err ) this->setstate(err);
  783.  
  784.   return *this;
  785.  
  786. }
  787.  
  788. /*
  789.  * istream_type& operator>>(double&)
  790.  */
  791.  
  792. template<class charT, class traits>
  793. basic_istream<charT, traits>&
  794. basic_istream<charT, traits>::operator>>(double& f)
  795. {
  796.  ios_base::iostate err = 0;
  797.  
  798.  #ifndef _RWSTD_NO_EXCEPTIONS
  799.  try {
  800.  #endif  
  801.  
  802. _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  803.  
  804. if(ipfx) {
  805.            #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  806.             use_facet<num_get<charT,istreambuf_iterator<charT,traits> > >(this->getloc())
  807.            #else
  808.             use_facet(this->getloc(),(num_get<charT,istreambuf_iterator<charT,traits> >*)0)
  809.            #endif
  810.             .get(istreambuf_iterator<charT,traits>(*this),istreambuf_iterator<charT,traits>(),*this,err,f);
  811.          }
  812.  
  813.   #ifndef _RWSTD_NO_EXCEPTIONS
  814.   }
  815.   #endif
  816.  
  817.   #ifndef _RWSTD_NO_EXCEPTIONS
  818.   catch(...)
  819.   {
  820.     bool flag = false;
  821.     try {
  822.            this->setstate(ios_base::badbit);
  823.         }
  824.     catch( ios_base::failure ) { flag= true; }
  825.     if ( flag ) throw;
  826.   }
  827.   #endif
  828.  
  829.   if ( err ) this->setstate(err);
  830.  
  831.   return *this;
  832.  
  833. }
  834.  
  835. /*
  836.  * istream_type& operator>>(long double&)
  837.  */
  838.  
  839. template<class charT, class traits>
  840. basic_istream<charT, traits>&
  841. basic_istream<charT, traits>::operator>>(long double& f)
  842. {
  843.  ios_base::iostate err = 0;
  844.  
  845.  #ifndef _RWSTD_NO_EXCEPTIONS
  846.  try {
  847.  #endif  
  848.  
  849.  _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  850.  
  851.  if(ipfx) {  
  852.              #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  853.               use_facet<num_get<charT,istreambuf_iterator<charT,traits> > >(this->getloc())
  854.              #else   
  855.              use_facet(this->getloc(),(num_get<charT,istreambuf_iterator<charT,traits> >*)0)
  856.              #endif
  857.               .get(istreambuf_iterator<charT,traits>(*this),istreambuf_iterator<charT,traits>(),*this,err,f);
  858.            }
  859.  
  860.   #ifndef _RWSTD_NO_EXCEPTIONS
  861.   }
  862.   #endif
  863.  
  864.   #ifndef _RWSTD_NO_EXCEPTIONS
  865.   catch(...)
  866.   {
  867.     bool flag = false;
  868.     try {
  869.            this->setstate(ios_base::badbit);
  870.         }
  871.     catch( ios_base::failure ) { flag= true; }
  872.     if ( flag ) throw;
  873.   }
  874.   #endif
  875.  
  876.   if ( err ) this->setstate(err);
  877.  
  878.   return *this;
  879. }
  880.  
  881. /*
  882.  * istream_type& operator>>(_RWSTD_LONG_LONG&)
  883.  */
  884.  
  885. #ifdef _RWSTD_LONG_LONG
  886.  
  887. template<class charT, class traits>
  888. basic_istream<charT, traits>&
  889. basic_istream<charT, traits>::operator>>(_RWSTD_LONG_LONG& ll)
  890. {
  891.  ios_base::iostate err = 0;
  892.  
  893.  #ifndef _RWSTD_NO_EXCEPTIONS
  894.  try {
  895.  #endif 
  896.  
  897.  _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  898.  
  899.  if(ipfx) { 
  900.              #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  901.               use_facet<num_get<charT,istreambuf_iterator<charT,traits> > >(this->getloc())
  902.              #else  
  903.              use_facet(this->getloc(),(num_get<charT,istreambuf_iterator<charT,traits> >*)0)
  904.              #endif
  905.               .get(istreambuf_iterator<charT,traits>(*this),istreambuf_iterator<charT,traits>(),*this,err,ll);
  906.            }
  907.  
  908.   #ifndef _RWSTD_NO_EXCEPTIONS
  909.   }
  910.   #endif
  911.  
  912.   #ifndef _RWSTD_NO_EXCEPTIONS
  913.   catch(...)
  914.   {
  915.     bool flag = false;
  916.     try {
  917.            this->setstate(ios_base::badbit);
  918.         }
  919.     catch( ios_base::failure ) { flag= true; }
  920.     if ( flag ) throw;
  921.   }
  922.   #endif
  923.  
  924.   if ( err ) this->setstate(err);
  925.  
  926.   return *this;
  927. }
  928. #endif // _RWSTD_LONG_LONG
  929.  
  930. /*
  931.  * istream_type& operator>>(void*&)
  932.  */
  933.  
  934. template<class charT, class traits>
  935. basic_istream<charT, traits>&
  936. basic_istream<charT, traits>::operator>>(void*& p)
  937. {
  938.   ios_base::iostate err = 0;
  939.  
  940.  #ifndef _RWSTD_NO_EXCEPTIONS
  941.  try {
  942.  #endif
  943.  
  944.   _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  945.  
  946.   if(ipfx) 
  947.  {
  948.    #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  949.     use_facet<num_get<charT,istreambuf_iterator<charT,traits> > >(this->getloc())
  950.    #else
  951.     use_facet(this->getloc(),(num_get<charT,istreambuf_iterator<charT,traits> >*)0)
  952.    #endif
  953.      .get(istreambuf_iterator<charT,traits>(*this),istreambuf_iterator<charT,traits>(),*this,err,p);
  954.   }
  955.  
  956.   #ifndef _RWSTD_NO_EXCEPTIONS
  957.   }
  958.   #endif
  959.  
  960.   #ifndef _RWSTD_NO_EXCEPTIONS
  961.   catch(...)
  962.   {
  963.     bool flag = false;
  964.     try {
  965.            this->setstate(ios_base::badbit);
  966.         }
  967.     catch( ios_base::failure ) { flag= true; }
  968.     if ( flag ) throw;
  969.   }
  970.   #endif
  971.  
  972.   if ( err ) this->setstate(err);
  973.   
  974.   return *this;
  975. }
  976.  
  977. /*
  978.  * istream_type& operator>>(basic_streambuf&)
  979.  *
  980.  * reads characters from the stream and inserts them into 'sb'
  981.  */
  982.  
  983. template<class charT, class traits>
  984. basic_istream<charT, traits>&
  985. basic_istream<charT, traits>::operator>>(streambuf_type& sb)
  986. {
  987.   ios_base::iostate err = 0;
  988.  
  989.   #ifndef _RWSTD_NO_EXCEPTIONS
  990.   try {
  991.   #endif  
  992.  
  993.   _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  994.  
  995.   if(ipfx) {
  996.     int_type         c;
  997.  
  998.     if ( traits::eq_int_type(rdbuf()->sgetc(),traits::eof()) ) 
  999.      err = ios_base::failbit; 
  1000.          
  1001.     while( !traits::eq_int_type( (c = rdbuf()->sgetc()),traits::eof()) ) {
  1002.         if( traits::eq_int_type(sb.sputc(c),traits::eof()) ) { 
  1003.         err = ios_base::failbit;
  1004.         break;
  1005.       }
  1006.       rdbuf()->sbumpc();  
  1007.     }
  1008.  
  1009.     if( traits::eq_int_type(c,traits::eof()) ) 
  1010.       err |= ios_base::eofbit;  
  1011.   }
  1012.  
  1013.   #ifndef _RWSTD_NO_EXCEPTIONS
  1014.   }
  1015.   #endif
  1016.  
  1017.   #ifndef _RWSTD_NO_EXCEPTIONS
  1018.   catch(...)
  1019.   {
  1020.     bool flag = false;
  1021.     try {
  1022.             this->setstate(ios_base::failbit);
  1023.         }
  1024.     catch( ios_base::failure ) { flag= true; }
  1025.     if ( flag ) throw;
  1026.   }
  1027.   #endif
  1028.  
  1029.   if ( err ) this->setstate(err);
  1030.  
  1031.   return *this;
  1032. }
  1033.  
  1034. /*
  1035.  * istream_type& operator>>(basic_streambuf *)
  1036.  *
  1037.  * reads characters from the stream and inserts them into 'sb'
  1038.  */
  1039.  
  1040. template<class charT, class traits>
  1041. basic_istream<charT, traits>&
  1042. basic_istream<charT, traits>::operator>>(streambuf_type *sb)
  1043. {
  1044.   ios_base::iostate err = 0;
  1045.  
  1046.   #ifndef _RWSTD_NO_EXCEPTIONS
  1047.   try {
  1048.   #endif 
  1049.  
  1050.  if ( sb!=0 )
  1051.  {
  1052.   
  1053.  
  1054.   _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this);
  1055.  
  1056.   if(ipfx) {
  1057.     int_type         c;
  1058.     
  1059.     if ( traits::eq_int_type(rdbuf()->sgetc(),traits::eof()) ) 
  1060.      err = ios_base::failbit; 
  1061.      
  1062.     while( !traits::eq_int_type( (c = rdbuf()->sgetc()),traits::eof()) ) {
  1063.       if( traits::eq_int_type(sb->sputc(c),traits::eof()) ) { 
  1064.         err = ios_base::failbit;
  1065.         break;
  1066.       }
  1067.       rdbuf()->sbumpc(); 
  1068.     }
  1069.  
  1070.        
  1071.     if( traits::eq_int_type(c,traits::eof()) )
  1072.       err |= ios_base::eofbit;
  1073.    }
  1074.  }
  1075. else
  1076.   err = ios_base::failbit;
  1077.  
  1078.   #ifndef _RWSTD_NO_EXCEPTIONS
  1079.   }
  1080.   #endif
  1081.  
  1082.   #ifndef _RWSTD_NO_EXCEPTIONS
  1083.   catch(...)
  1084.   {
  1085.     bool flag = false;
  1086.     try {
  1087.             this->setstate(ios_base::failbit);
  1088.         }
  1089.     catch( ios_base::failure ) { flag= true; }
  1090.     if ( flag ) throw;
  1091.   }
  1092.   #endif
  1093.  
  1094.   if ( err ) this->setstate(err);
  1095.  
  1096.   return *this;
  1097. }
  1098.  
  1099. /*
  1100.  * istream_type& get(char_type *, streamsize, char_type)
  1101.  *
  1102.  */
  1103.  
  1104. template<class charT, class traits>
  1105. basic_istream<charT, traits>&
  1106. basic_istream<charT, traits>::
  1107. get(char_type *s, streamsize n, char_type delim)
  1108. {
  1109.  ios_base::iostate err = 0; 
  1110.  
  1111.  #ifndef _RWSTD_NO_EXCEPTIONS
  1112.  try {
  1113.  #endif  
  1114.  
  1115.  chcount_ = 0; 
  1116.  
  1117.  if (s!=0)
  1118.  {
  1119.  
  1120.   _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this,1);
  1121.  
  1122.   if(ipfx) { 
  1123.     char_type  *op = s;
  1124.     int_type   c = 0;
  1125.  
  1126.     while(--n > 0 && (c = rdbuf()->sgetc()) != delim && 
  1127.      ( !traits::eq_int_type(c,traits::eof()) )) {
  1128.       *s++ = c; 
  1129.       ++chcount_;
  1130.       rdbuf()->snextc(); 
  1131.     }
  1132.  
  1133.     if( traits::eq_int_type(c,traits::eof()) )  
  1134.       err = ((s == op) ? (ios_base::eofbit | ios_base::failbit) :
  1135.                            ios_base::eofbit);
  1136.   }
  1137.  
  1138.   *s = 0;   //terminate with null
  1139.  }
  1140. else
  1141.   err = ios_base::badbit;
  1142.  
  1143.   #ifndef _RWSTD_NO_EXCEPTIONS
  1144.   }
  1145.   #endif
  1146.  
  1147.   #ifndef _RWSTD_NO_EXCEPTIONS
  1148.   catch(...)
  1149.   {
  1150.     bool flag = false;
  1151.     try {
  1152.             this->setstate(ios_base::badbit);
  1153.         }
  1154.     catch( ios_base::failure ) { flag= true; }
  1155.     if ( flag ) throw;
  1156.   }
  1157.   #endif
  1158.  
  1159.   if ( err ) this->setstate(err);
  1160.  
  1161.   return *this;
  1162. }
  1163.  
  1164. /*
  1165.  * istream_type& get(char_type&)
  1166.  *
  1167.  * gets a single character, first skipping white space.
  1168.  * see also: int_type get();
  1169.  */
  1170.  
  1171. template<class charT, class traits>
  1172. basic_istream<charT, traits>&
  1173. basic_istream<charT, traits>::get(char_type& s)
  1174. {
  1175.  ios_base::iostate err = 0;  
  1176.  
  1177.  #ifndef _RWSTD_NO_EXCEPTIONS
  1178.  try {
  1179.  #endif
  1180.  
  1181.   _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this,1);
  1182.  
  1183.   chcount_ = 0;
  1184.  
  1185.   if(ipfx) { 
  1186.              int_type tmp = rdbuf()->sbumpc();
  1187.              if ( traits::eq_int_type(tmp,traits::eof()) ) 
  1188.               {
  1189.                 err = ios_base::failbit | ios_base::eofbit;
  1190.               }
  1191.              else
  1192.               {
  1193.                 s = traits::to_char_type(tmp);
  1194.                 chcount_ = 1;
  1195.               }
  1196.   }
  1197.  
  1198.   #ifndef _RWSTD_NO_EXCEPTIONS
  1199.   }
  1200.   #endif
  1201.  
  1202.   #ifndef _RWSTD_NO_EXCEPTIONS
  1203.   catch(...)
  1204.   {
  1205.     bool flag = false;
  1206.     try {
  1207.             this->setstate(ios_base::badbit);
  1208.         }
  1209.     catch( ios_base::failure ) { flag= true; }
  1210.     if ( flag ) throw;
  1211.   }
  1212.   #endif
  1213.  
  1214.   if ( err ) this->setstate(err);
  1215.  
  1216.   return *this;
  1217. }
  1218.  
  1219. /*
  1220.  * istream_type& get(basic_streambuf&, char_type)
  1221.  *
  1222.  * insert characters into sb upto delim
  1223.  */
  1224.  
  1225. template<class charT, class traits>
  1226. basic_istream<charT, traits>&
  1227. basic_istream<charT, traits>::
  1228. get(streambuf_type& sb, char_type delim)
  1229. {
  1230.  ios_base::iostate err = 0;   
  1231.  
  1232.  #ifndef _RWSTD_NO_EXCEPTIONS
  1233.  try {
  1234.  #endif
  1235.  
  1236.   _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this,1);
  1237.  
  1238.   chcount_ = 0;
  1239.  
  1240.   if(ipfx) { 
  1241.     int_type        c;
  1242.  
  1243.     while(((c = rdbuf()->sgetc()) != delim) && 
  1244.      ( !traits::eq_int_type(c,traits::eof()) )) {
  1245.       if( traits::eq_int_type(sb.sputc(c),traits::eof()) ) {  
  1246.         err = ios_base::failbit;  
  1247.         break;
  1248.       }
  1249.       ++chcount_;
  1250.       rdbuf()->sbumpc();  
  1251.     }
  1252.  
  1253.     if(c == traits::eof())  
  1254.       err |= ios_base::eofbit;
  1255.   }
  1256.  
  1257.   #ifndef _RWSTD_NO_EXCEPTIONS
  1258.   }
  1259.   #endif
  1260.  
  1261.   #ifndef _RWSTD_NO_EXCEPTIONS
  1262.   catch(...)
  1263.   {
  1264.     bool flag = false;
  1265.     try {
  1266.             this->setstate(ios_base::badbit);
  1267.         }
  1268.     catch( ios_base::failure ) { flag= true; }
  1269.     if ( flag ) throw;
  1270.   }
  1271.   #endif
  1272.  
  1273.   if ( err ) this->setstate(err);
  1274.  
  1275.   return *this;
  1276. }
  1277.  
  1278. /*
  1279.  * istream_type& getline(char_type *, streamsize, char_type)
  1280.  */
  1281.  
  1282. template<class charT, class traits>
  1283. basic_istream<charT, traits>&
  1284. basic_istream<charT, traits>::
  1285. getline(char_type *s, streamsize n, char_type delim)
  1286. {
  1287.  ios_base::iostate err = 0;
  1288.  
  1289.  #ifndef _RWSTD_NO_EXCEPTIONS
  1290.  try {
  1291.  #endif
  1292.  
  1293.  chcount_ = 0; 
  1294.  
  1295.  if (s!=0)
  1296.  {
  1297.  
  1298.   _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this,1);
  1299.  
  1300.   if(ipfx) {  
  1301.     char_type    *op = s;
  1302.     int_type     c = 0;
  1303.  
  1304.  while( --n > 0 && !traits::eq_int_type( (c = rdbuf()->sgetc()),traits::eof()) ) {
  1305.       ++chcount_;
  1306.       rdbuf()->sbumpc();  
  1307.  
  1308.       if(c == delim)
  1309.          break;
  1310.  
  1311.       *s++ = c;          
  1312.     }
  1313.     *s = 0; 
  1314.     if( traits::eq_int_type(c,traits::eof()) )  
  1315.   err = (s == op) ? (ios_base::eofbit | ios_base::failbit) : ios_base::eofbit;
  1316.  
  1317.     if ( n == 0 ) 
  1318.      {
  1319.        if ( rdbuf()->sgetc() != delim )
  1320.         err |= ios_base::failbit;
  1321.        else
  1322.         rdbuf()->snextc();
  1323.      }
  1324.  
  1325.   }
  1326.   
  1327.   *s = 0;  //terminate with null
  1328.  }
  1329. else
  1330.  err = ios_base::badbit;
  1331.  
  1332.   #ifndef _RWSTD_NO_EXCEPTIONS
  1333.   }
  1334.   #endif
  1335.  
  1336.   #ifndef _RWSTD_NO_EXCEPTIONS
  1337.   catch(...)
  1338.   {
  1339.     bool flag = false;
  1340.     try {
  1341.              this->setstate(ios_base::badbit);
  1342.         }
  1343.     catch( ios_base::failure ) { flag= true; }
  1344.     if ( flag ) throw;
  1345.   }
  1346.   #endif
  1347.  
  1348.   if ( err ) this->setstate(err);
  1349.  
  1350.   return *this;
  1351. }
  1352.  
  1353. /*
  1354.  * istream_type& ignore(streamsize, int_type)
  1355.  *
  1356.  * this ignores characters n characters or until delim
  1357.  */
  1358.  
  1359. template<class charT, class traits>
  1360. basic_istream<charT, traits>&
  1361. basic_istream<charT, traits>::ignore(streamsize n, int_type delim)
  1362. {
  1363.   _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this,1);
  1364.   
  1365.   chcount_ = 0;
  1366.  
  1367.   if(ipfx) {  
  1368.     int_type      c = 0;
  1369.  
  1370.  while(--n >= 0 && !traits::eq_int_type( (c = rdbuf()->sgetc()),traits::eof()) ) {
  1371.       ++chcount_;
  1372.       rdbuf()->sbumpc();
  1373.       if(c == delim)   
  1374.         break;
  1375.     }
  1376.     if( traits::eq_int_type(c,traits::eof()) )
  1377.       this->setstate(ios_base::eofbit);
  1378.   }
  1379.  
  1380.   return *this;
  1381. }
  1382.  
  1383. /*
  1384.  * istream_type& read(char_type *, streamsize)
  1385.  */
  1386.  
  1387. template<class charT, class traits>
  1388. basic_istream<charT, traits>&
  1389. basic_istream<charT, traits>::read(char_type *s, streamsize n)
  1390. {
  1391.  ios_base::iostate err = 0; 
  1392.  
  1393.  #ifndef _RWSTD_NO_EXCEPTIONS
  1394.  try {
  1395.  #endif 
  1396.  
  1397.  chcount_ = 0;
  1398.  
  1399.  if (s!=0)
  1400.  { 
  1401.  
  1402.   _TYPENAME basic_istream<charT, traits>::sentry ipfx(*this,1);
  1403.  
  1404.   if(ipfx) {  
  1405.     int_type       c = 0;
  1406.  
  1407. while((--n >= 0) && !traits::eq_int_type( (c = rdbuf()->sgetc()),traits::eof()))
  1408.    {
  1409.       *s++ = c; 
  1410.       ++chcount_;
  1411.       rdbuf()->sbumpc();  
  1412.     }
  1413.  
  1414.     if( traits::eq_int_type(c,traits::eof()) )  
  1415.     err = (n >= 0) ? (ios_base::eofbit | ios_base::failbit) : ios_base::eofbit;
  1416.   }
  1417.  
  1418.  }
  1419.  else
  1420.   err = ios_base::badbit;  
  1421.  
  1422.   #ifndef _RWSTD_NO_EXCEPTIONS
  1423.   }
  1424.   #endif
  1425.  
  1426.   #ifndef _RWSTD_NO_EXCEPTIONS
  1427.   catch(...)
  1428.   {
  1429.     bool flag = false;
  1430.     try {
  1431.              this->setstate(ios_base::badbit);
  1432.         }
  1433.     catch( ios_base::failure ) { flag= true; }
  1434.     if ( flag ) throw;
  1435.   }
  1436.   #endif
  1437.  
  1438.   if ( err ) this->setstate(err);
  1439.  
  1440.   return *this;
  1441. }
  1442.  
  1443. /*
  1444.  * streamsize readsome(char_type *, streamsize)
  1445.  */
  1446.  
  1447. template<class charT, class traits>
  1448. streamsize 
  1449. basic_istream<charT, traits>::readsome(char_type *s, streamsize n)
  1450. {
  1451.   int navail = rdbuf()->in_avail();
  1452.  
  1453.    
  1454.   if(navail == -1) {   
  1455.     this->setstate(ios_base::eofbit);
  1456.     return 0;
  1457.   }
  1458.   if(navail == 0 ) return 0;
  1459.  
  1460.  if ( this->good() )
  1461.  {
  1462.   if(n < navail) 
  1463.     { 
  1464.       read(s, n);
  1465.       return (n);
  1466.     }
  1467.  
  1468.   read(s, navail);
  1469.   return (streamsize)(navail);
  1470.  }
  1471.  else
  1472.   { 
  1473.     if ( !(this->rdstate() & ios_base::failbit) )
  1474.      this->setstate(ios_base::failbit);
  1475.   }
  1476.   
  1477.   return 0;
  1478. }
  1479.  
  1480. /*
  1481.  * int peek()
  1482.  */
  1483.  
  1484. template<class charT, class traits>
  1485. int basic_istream<charT, traits>::peek()
  1486. {
  1487.   chcount_ = 0;
  1488.  
  1489.   if(this->good())
  1490.    {
  1491.      #ifdef _RWSTD_MULTI_THREAD
  1492.       if ( rdbuf() )
  1493.        _RWSTDGuard guard(this->rdbuf()->buffer_mutex_);
  1494.      #endif
  1495.  
  1496.      _TYPENAME traits::int_type tmp = rdbuf()->sgetc();
  1497.      if ( !traits::eq_int_type( tmp,traits::eof() ) )
  1498.       chcount_ = 1;
  1499.      return tmp;
  1500.    }
  1501.  
  1502.   return traits::eof();
  1503. }
  1504.  
  1505. /*
  1506.  * pos_type tellg()
  1507.  */
  1508.  
  1509. template<class charT, class traits>
  1510. _TYPENAME basic_istream<charT, traits>::pos_type
  1511. basic_istream<charT, traits>::tellg()
  1512. {
  1513.  ios_base::iostate err = 0; 
  1514.  pos_type         p;
  1515.  
  1516.   #ifndef _RWSTD_NO_EXCEPTIONS
  1517.  try {
  1518.  #endif 
  1519.  
  1520.   #ifdef _RWSTD_MULTI_THREAD
  1521.    if ( rdbuf() )
  1522.     _RWSTDGuard guard(this->rdbuf()->buffer_mutex_);
  1523.   #endif
  1524.  
  1525.   if ( this->bad() ) return pos_type(off_type(-1));   
  1526.  
  1527.   if((p = rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in))
  1528.    == pos_type(off_type(-1)))
  1529.     err = ios_base::failbit;
  1530.  
  1531.   #ifndef _RWSTD_NO_EXCEPTIONS
  1532.   }
  1533.   #endif
  1534.  
  1535.   #ifndef _RWSTD_NO_EXCEPTIONS
  1536.   catch(...)
  1537.   {
  1538.     bool flag = false;
  1539.     try {
  1540.           this->setstate(ios_base::badbit);
  1541.         }
  1542.     catch( ios_base::failure ) { flag= true; }
  1543.     if ( flag ) throw;
  1544.   }
  1545.   #endif
  1546.  
  1547.   if ( err ) this->setstate(err);
  1548.  
  1549.   return p;
  1550. }
  1551.  
  1552. /*
  1553.  * basic_istream& seekg(off_type, ios_base::seekdir)
  1554.  */
  1555.  
  1556. #ifndef _RWSTD_NO_INT_TYPEDEF
  1557. template<class charT, class traits>
  1558. basic_istream<charT, traits>&
  1559. basic_istream<charT, traits>::
  1560. seekg(off_type off, ios_base::seekdir dir)
  1561. {
  1562.  ios_base::iostate err = 0;
  1563.  
  1564.  #ifndef _RWSTD_NO_EXCEPTIONS
  1565.  try {
  1566.  #endif 
  1567.  
  1568.    #ifdef _RWSTD_MULTI_THREAD
  1569.     if ( rdbuf() )
  1570.      _RWSTDGuard guard(this->rdbuf()->buffer_mutex_);
  1571.    #endif 
  1572.  
  1573. if ( !this->bad() )
  1574.  {
  1575.   if (rdbuf())
  1576.   {
  1577.    if( rdbuf()->pubseekoff(off, dir, ios_base::in) == pos_type(off_type(-1)) )
  1578.     err = ios_base::failbit;
  1579.   }
  1580.   else
  1581.    err = ios_base::badbit;
  1582.  }
  1583.  
  1584.   #ifndef _RWSTD_NO_EXCEPTIONS
  1585.   }
  1586.   #endif
  1587.  
  1588.   #ifndef _RWSTD_NO_EXCEPTIONS
  1589.   catch(...)
  1590.   {
  1591.     bool flag = false;
  1592.     try {
  1593.           this->setstate(ios_base::badbit);
  1594.         }
  1595.     catch( ios_base::failure ) { flag= true; }
  1596.     if ( flag ) throw;
  1597.   }
  1598.   #endif
  1599.  
  1600.  if ( err ) this->setstate(err);
  1601.   else
  1602.    if ( !this->bad() )
  1603.     clear(this->rdstate() & ~(ios_base::eofbit | ios_base::failbit));
  1604.  
  1605.   return *this;
  1606. }
  1607. #endif
  1608.  
  1609. /*
  1610.  * istream_type& putback(char_type)
  1611.  */
  1612.  
  1613. template<class charT, class traits>
  1614. basic_istream<charT, traits>&
  1615. basic_istream<charT, traits>::putback(char_type c)
  1616. {
  1617.   ios_base::iostate err = 0;
  1618.  
  1619.   #ifndef _RWSTD_NO_EXCEPTIONS
  1620.   try {
  1621.   #endif 
  1622.   
  1623.   #ifdef _RWSTD_MULTI_THREAD
  1624.    if ( rdbuf() )
  1625.     _RWSTDGuard guard(this->rdbuf()->buffer_mutex_);
  1626.   #endif 
  1627.  
  1628.  if (this->good())
  1629.    {
  1630.      if( traits::eq_int_type(rdbuf()->sputbackc(c),traits::eof()) ) 
  1631.       err = ios_base::badbit;      
  1632.   }
  1633.  else
  1634.   { 
  1635.     if ( !(this->rdstate() & ios_base::failbit) )
  1636.      this->setstate(ios_base::failbit);
  1637.   }
  1638.  
  1639.   #ifndef _RWSTD_NO_EXCEPTIONS
  1640.   }
  1641.   #endif
  1642.  
  1643.   #ifndef _RWSTD_NO_EXCEPTIONS
  1644.   catch(...)
  1645.   {
  1646.     bool flag = false;
  1647.     try {
  1648.           this->setstate(ios_base::badbit);
  1649.         }
  1650.     catch( ios_base::failure ) { flag= true; }
  1651.     if ( flag ) throw;
  1652.   }
  1653.   #endif
  1654.  
  1655.   if ( err ) this->setstate(err);
  1656.  
  1657.   return *this;
  1658. }
  1659.  
  1660. /*
  1661.  * istream_type& unget()
  1662.  */
  1663.  
  1664. template<class charT, class traits>
  1665. basic_istream<charT, traits>&
  1666. basic_istream<charT, traits>::unget()
  1667. {
  1668.   ios_base::iostate err = 0;
  1669.  
  1670.   #ifndef _RWSTD_NO_EXCEPTIONS
  1671.   try {
  1672.   #endif 
  1673.  
  1674.   #ifdef _RWSTD_MULTI_THREAD
  1675.    if ( rdbuf() )
  1676.     _RWSTDGuard guard(this->rdbuf()->buffer_mutex_);
  1677.   #endif
  1678.  
  1679.   if (this->good())
  1680.    {
  1681.      if( traits::eq_int_type(rdbuf()->sungetc(),traits::eof()) )
  1682.       err = ios_base::badbit;  
  1683.    }
  1684.  else
  1685.   { 
  1686.     if ( !(this->rdstate() & ios_base::failbit) )
  1687.      this->setstate(ios_base::failbit);
  1688.   }
  1689.  
  1690.   #ifndef _RWSTD_NO_EXCEPTIONS
  1691.   }
  1692.   #endif
  1693.  
  1694.   #ifndef _RWSTD_NO_EXCEPTIONS
  1695.   catch(...)
  1696.   {
  1697.     bool flag = false;
  1698.     try {
  1699.           this->setstate(ios_base::badbit);
  1700.         }
  1701.     catch( ios_base::failure ) { flag= true; }
  1702.     if ( flag ) throw;
  1703.   }
  1704.   #endif
  1705.  
  1706.   if ( err ) this->setstate(err);
  1707.  
  1708.   return *this;
  1709. }
  1710.  
  1711. /*
  1712.  * streamsize gcount() const
  1713.  */
  1714.  
  1715. template<class charT, class traits>
  1716. streamsize basic_istream<charT, traits>::gcount() const
  1717. {
  1718.   return chcount_;
  1719. }
  1720.  
  1721.  
  1722. /*
  1723.  * int sync()
  1724.  */
  1725.  
  1726. template<class charT, class traits>
  1727. int basic_istream<charT, traits>::sync()
  1728. {
  1729.    ios_base::iostate err = 0;
  1730.  
  1731.    #ifndef _RWSTD_NO_EXCEPTIONS
  1732.    try {
  1733.    #endif 
  1734.   
  1735.   #ifdef _RWSTD_MULTI_THREAD
  1736.    if ( rdbuf() )
  1737.     _RWSTDGuard guard(this->rdbuf()->buffer_mutex_);
  1738.   #endif
  1739.  
  1740.   if(rdbuf()) 
  1741. {  
  1742.  
  1743.     if(rdbuf()->pubsync() == -1)
  1744.       err = ios_base::badbit;  
  1745.     else
  1746.       {
  1747.         if ( this->rdstate() & ios_base::eofbit )
  1748.          clear( this->rdstate() & ~(ios_base::eofbit | ios_base::failbit));
  1749.         return 0;
  1750.       } 
  1751.   }
  1752.  
  1753.   #ifndef _RWSTD_NO_EXCEPTIONS
  1754.   }
  1755.   #endif
  1756.  
  1757.   #ifndef _RWSTD_NO_EXCEPTIONS
  1758.   catch(...)
  1759.   {
  1760.     bool flag = false;
  1761.     try {
  1762.           this->setstate(ios_base::badbit);
  1763.         }
  1764.     catch( ios_base::failure ) { flag= true; }
  1765.     if ( flag ) throw;
  1766.   }
  1767.   #endif
  1768.  
  1769.   if ( err ) this->setstate(err);
  1770.  
  1771.   return -1;
  1772. }
  1773.  
  1774.  
  1775. // string extractor and getline
  1776.  
  1777. #ifndef _RWSTD_NO_NAMESPACE
  1778. }
  1779. namespace __rwstd {
  1780. using namespace std;
  1781. #endif
  1782.  
  1783. template <class streamT, class stringT, class traits>
  1784. streamT& _RWSTDExport rw_extract_string(streamT& is, stringT& s, traits)
  1785. {
  1786.     _TYPENAME streamT::int_type c;
  1787.     ios_base::iostate err = 0;
  1788.  
  1789.  #ifndef _RWSTD_NO_EXCEPTIONS
  1790.  try {
  1791.  #endif  
  1792.  
  1793.     _TYPENAME streamT::sentry ipfx(is);
  1794.  
  1795.     if(ipfx) { 
  1796.  
  1797.       s.erase();
  1798.       c = is.rdbuf()->sbumpc();
  1799.  
  1800.       const ctype<streamT::char_type>& ctype_facet =
  1801. #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  1802.         use_facet<ctype<streamT::char_type> >(is.getloc());
  1803. #else
  1804.         use_facet(is.getloc(),(ctype<streamT::char_type>*)0);
  1805. #endif
  1806.  
  1807.       _TYPENAME stringT::size_type i   = 0;
  1808.  
  1809.       _TYPENAME stringT::size_type end = s.max_size();
  1810.       if (is.width())
  1811.         end = (end > (stringT::size_type)is.width()) ? is.width() : end;
  1812.  
  1813.       while ( !traits::eq_int_type(c,traits::eof()) &&  !ctype_facet.is(ctype_facet.space,c) )
  1814.       {
  1815.         s.append(1,traits::to_char_type(c));
  1816.         i++;
  1817.         if ( i == end ) break;
  1818.         c = is.rdbuf()->sbumpc();
  1819.       }
  1820.     if ( i == 0 ) err |= ios_base::failbit;
  1821.     if ( traits::eq_int_type(c,traits::eof()) ) 
  1822.      err |= ios_base::eofbit;
  1823.  
  1824.     }
  1825.  
  1826.   #ifndef _RWSTD_NO_EXCEPTIONS
  1827.   }
  1828.   #endif
  1829.  
  1830.   #ifndef _RWSTD_NO_EXCEPTIONS
  1831.   catch(...)
  1832.   {
  1833.     bool flag = false;
  1834.     try {
  1835.            is.setstate(ios_base::badbit);
  1836.         }
  1837.     catch( ios_base::failure ) { flag= true; }
  1838.     if ( flag ) throw;
  1839.   }
  1840.   #endif
  1841.  
  1842.   if ( err ) is.setstate(err);
  1843.  
  1844.   return is;
  1845. }
  1846.  
  1847.  
  1848. #ifndef _RWSTD_NO_NAMESPACE
  1849. }
  1850. namespace std {
  1851. #endif
  1852.  
  1853. template<class charT, class traits, class Allocator>
  1854. basic_istream<charT,traits>&
  1855. _RWSTDExport getline (basic_istream<charT,traits>& is,
  1856.          basic_string<charT,traits,Allocator>& str,
  1857.          charT delim )
  1858. {
  1859.     _TYPENAME traits::int_type c;
  1860.     ios_base::iostate err = 0;
  1861.  
  1862.  #ifndef _RWSTD_NO_EXCEPTIONS
  1863.  try {
  1864.  #endif  
  1865.  
  1866.     _TYPENAME basic_istream<charT,traits>::sentry ipfx(is,1);
  1867.  
  1868.     if(ipfx) { 
  1869.  
  1870.     str.erase();
  1871.     
  1872.     c = is.rdbuf()->sbumpc();
  1873.     _TYPENAME Allocator::size_type i = 0;
  1874.  
  1875.       while ( !traits::eq_int_type(c,traits::eof()) )
  1876.       {
  1877.         i++;
  1878.         if ( traits::eq(traits::to_char_type(c),delim) )
  1879.             break;
  1880.         if (i == str.max_size())
  1881.         {
  1882.           err |= ios_base::failbit;
  1883.           break;
  1884.         }
  1885.         str.append(1,traits::to_char_type(c));
  1886.         c = is.rdbuf()->sbumpc();
  1887.       }
  1888.  
  1889.      if ( traits::eq_int_type(c,traits::eof()) )
  1890.       err |= ios_base::eofbit;
  1891.  
  1892.     if ( i==0 )
  1893.      err |= ios_base::failbit;
  1894.  
  1895.     }
  1896.  
  1897.  
  1898.   #ifndef _RWSTD_NO_EXCEPTIONS
  1899.   }
  1900.   #endif
  1901.  
  1902.   #ifndef _RWSTD_NO_EXCEPTIONS
  1903.   catch(...)
  1904.   {
  1905.     bool flag = false;
  1906.     try {
  1907.            is.setstate(ios_base::badbit);
  1908.         }
  1909.     catch( ios_base::failure ) { flag= true; }
  1910.     if ( flag ) throw;
  1911.   }
  1912.   #endif
  1913.  
  1914.   if ( err ) is.setstate(err);
  1915.  
  1916.   return is;
  1917. }  
  1918.  
  1919.  
  1920. /*
  1921.  *
  1922.  * class basic_iostream
  1923.  *
  1924.  */
  1925.  
  1926. /*
  1927.  * basic_iostream(basic_streambuf *)
  1928.  */
  1929.  
  1930. template<class charT, class traits>
  1931. basic_iostream<charT, traits>::
  1932. basic_iostream(basic_streambuf<charT, traits> *sb)
  1933. :basic_istream<charT, traits>(sb)
  1934. ,basic_ostream<charT, traits>(sb)
  1935. {
  1936. }
  1937.  
  1938. /*
  1939.  * basic_iostream( )
  1940.  */
  1941.  
  1942. template<class charT, class traits>
  1943. basic_iostream<charT, traits>::
  1944. basic_iostream( )
  1945. {
  1946. }
  1947.  
  1948.  
  1949. /*
  1950.  * ~basic_iostream()
  1951.  */
  1952.  
  1953. template<class charT, class traits>
  1954. basic_iostream<charT, traits>::
  1955. ~basic_iostream()
  1956. {
  1957.  
  1958. }
  1959.  
  1960. #ifndef _RWSTD_NO_NAMESPACE
  1961. }
  1962. #endif
  1963.  
  1964. #pragma option pop
  1965. #endif /* __ISTREAM_CC */
  1966.